home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / putz / putzwind.i < prev   
Text File  |  1997-10-26  |  42KB  |  1,270 lines
  1. IMPLEMENTATION MODULE PutzWindows;
  2.  
  3. FROM SYSTEM IMPORT ADDRESS, ADR, CADR, CALLSYS, TSIZE;
  4.  
  5. FROM Storage    IMPORT ALLOCATE, DEALLOCATE;
  6.  
  7. (* MM2 *)
  8.  
  9. FROM GrafBase  IMPORT Rect, Rectangle, LongRect, Point;
  10.  
  11. FROM Lists      IMPORT List, ResetList, NextEntry, NoOfEntries;
  12.  
  13. IMPORT Keyboard, MOSGlobals, BinOps, Strings, StrConv;
  14.  
  15. FROM Keyboard  IMPORT SpecialCode;
  16.  
  17. FROM Directory          IMPORT  GetDefaultPath, SetDefaultPath, Delete, Rename;
  18.  
  19. FROM FileNames          IMPORT  ValidatePath, SplitPath, FileName;
  20.  
  21. (* Magic *)
  22.  
  23. FROM MagicSys   IMPORT  sINTEGER;
  24.  
  25. IMPORT mtAppl, mtUtils, mtDials, mtTextfiles, mtDir, mtAlerts;
  26.  
  27. IMPORT MagicAES, MagicVDI, MagicStrings, MagicDOS, MagicFSM;
  28.  
  29. FROM MagicVDI   IMPORT  MFDB, VDICall, VDIIntIn, VDIPtsIn, VDIControl;
  30.  
  31. (* CAT *)
  32. IMPORT FontSelect;
  33. IMPORT WdwManager, RectFuncs, CatGlobal;
  34. IMPORT ConfVars, Clip, MTPaths;
  35. IMPORT dataSys;
  36. FROM Void IMPORT v;
  37.  
  38. (* CatPutz *)
  39. IMPORT PutzDo;
  40. IMPORT PutzRsc;
  41. IMPORT PutzList;
  42. IMPORT PutzGroup;
  43. IMPORT PutzTypes;
  44. IMPORT PutzGr;
  45.  
  46. FROM PutzTypes  IMPORT TextJustification, ptrDispEntry, 
  47.                        listEntryType, putzList, 
  48.                        ptrGrEntry, groupDeleted,
  49.                        defaultOpts;
  50.  
  51. IMPORT PutzHelp;
  52.  
  53. IMPORT Catputz2;
  54. (*$R-,S-*)
  55.  
  56. CONST  noClipAlt = '[3][CATPUTZ:|Konnte nicht auf|das Clipboard schreiben!][[Abbruch]';
  57.        doDelAlt = '[3][CATPUTZ:|L”schen in den selektierten|Gruppen starten?][[Ja|:[Nein]';
  58.  
  59. CONST   (* Variablennamen *)
  60.         cWdwRect    = 'StatWindowRect';
  61.         cWdwFont    = 'StatFont';
  62.         cWdwFontSize= 'StatFontSize';
  63.         cWdwTop     = 'StatWindowStart';
  64.         cWdwLineDist= 'StatWindowLineDist';
  65.         cWdwLeftOffs= 'StatWindowLeftOffset';
  66.         cWdwOpen    = 'StatWindowOpen';
  67.  
  68.   
  69. TYPE WdwPtr = POINTER TO wlRec;
  70.  
  71.      wlRec      = RECORD
  72.                     list        : List;         (*  list with attr.s  *)
  73.                     wdw         : sINTEGER;
  74.                     vdi         : sINTEGER;
  75.                     font        : INTEGER;
  76.                     fontSize    : sINTEGER;
  77.                     fontScalable: BOOLEAN;
  78.                     charHeight, 
  79.                     charWidth   : INTEGER;
  80.                     windLines   : INTEGER;
  81.                     maxWidth    : INTEGER;
  82.                     startLine   : INTEGER;
  83.                     leftOffset  : INTEGER;
  84.                     currSize    : Rectangle;
  85.                     butWork     : Rectangle;
  86.                     isHidden    : BOOLEAN;
  87.                     lastOb      : INTEGER;
  88.                     isLocked    : BOOLEAN;  (* Liste wird gerade ver„ndert *)
  89.                   END;
  90.  
  91.         (* globale Variablen *)
  92. VAR     
  93.         inOpen  : BOOLEAN;
  94.         pixOff  : INTEGER;
  95.         lineDist: INTEGER;
  96.         lineHeight: INTEGER;
  97.         inDelete: BOOLEAN;
  98.         
  99.         windows : WdwPtr;
  100.         butBox  : mtUtils.tObjcTree;
  101.  
  102. PROCEDURE outputText(displayList: List; f: mtTextfiles.TEXTFILE; isCsv : BOOLEAN);
  103.   VAR entry   : ptrDispEntry;
  104.       str     : PutzTypes.MaxStr;
  105.       i       : CARDINAL;
  106.       j       : INTEGER;
  107.       part    : INTEGER;
  108. BEGIN 
  109.   (* Ausgabe *)
  110.   CatGlobal.busyMouse;
  111.   ResetList (displayList);
  112.   entry := NextEntry (displayList);
  113.   i := 0;
  114.   WHILE entry # NIL DO
  115.     INC (i);
  116.     IF i MOD 7 = 0 THEN CatGlobal.busyMouse(); END;
  117.     IF entry^.type = separatorLine
  118.     THEN
  119.       IF ~isCsv
  120.       THEN
  121.         FOR j := 0 TO PutzList.GetMaxLineWidth() DO
  122.           IF j+1 < TSIZE (PutzTypes.MaxStr)
  123.           THEN
  124.             str[j] := '=';
  125.             str[j+1] := '=';
  126.           END;
  127.         END;
  128.         mtTextfiles.WriteLine (f, str);
  129.         mtTextfiles.WriteLn (f);
  130.       END;
  131.     ELSE
  132.       FOR part := 0 TO PutzList.GetPartCount() DO
  133.         PutzList.GetPart (entry, part, str, ~isCsv);
  134.         mtTextfiles.WriteLine (f, str);
  135.         IF isCsv
  136.         THEN
  137.           (* Separator schreiben *)
  138.           mtTextfiles.WriteLine (f, ",");
  139.         END;
  140.       END;
  141.       mtTextfiles.WriteLn (f);
  142.     END;
  143.     entry := NextEntry (displayList);
  144.   END;
  145.   (* File wieder schliežen *)
  146.   mtTextfiles.CloseTextfile (f);
  147. END outputText;
  148.  
  149. PROCEDURE OutputStat (ptr: WdwPtr);
  150.   VAR f     : INTEGER;
  151.       tf    : mtTextfiles.TEXTFILE;
  152.       fName : PutzTypes.FileStr;
  153.       fnShort : PutzTypes.FileStr;
  154.       msg     : PutzTypes.MaxStr;
  155.       targetPath: PutzTypes.FileStr;
  156. BEGIN
  157.   WITH ptr^ DO
  158.     (* Filenamen erfragen *)
  159.     MagicStrings.Assign (MTPaths.DataPath, targetPath);
  160.     MagicStrings.Assign ('', fName);
  161.     IF PutzGr.SelectFile ("Ausgabedatei:", "*.TXT", targetPath, fName, TRUE)
  162.     THEN
  163.       (* Datei anlegen *)
  164.       MagicStrings.Assign (FileName (fName), fnShort);
  165.       f := MagicDOS.Fopen (fName, {});
  166.       IF f > 0
  167.       THEN
  168.         v.int := MagicDOS.Fclose (f);
  169.         (* File existiert, nachfragen *)
  170.         mtAppl.MouseArrow();
  171.         MagicStrings.Assign ('[2][CATPUTZ|Die Datei existiert schon!|Datei:|', msg);
  172.         MagicStrings.Append (fnShort, msg);
  173.         MagicStrings.Append ('][[Ersetzen|An[h„ngen|[Abbruch]', msg);
  174.         v.int := mtAlerts.Alert (2,msg);
  175.         IF v.int = 3 THEN RETURN END;
  176.         IF v.int = 2
  177.         THEN
  178.           IF ~mtTextfiles.OpenTextfile (fName, mtTextfiles.APPEND, 32000, tf)
  179.           THEN
  180.             RETURN
  181.           END;
  182.         ELSE 
  183.           IF ~mtTextfiles.OpenTextfile (fName, mtTextfiles.WRITE, 32000, tf)
  184.           THEN
  185.             RETURN
  186.           END;
  187.         END;
  188.       ELSE
  189.         IF ~mtTextfiles.OpenTextfile (fName, mtTextfiles.WRITE, 32000, tf)
  190.         THEN
  191.           RETURN
  192.         END;
  193.       END;
  194.       outputText (list, tf, FALSE);
  195.       mtAppl.MouseArrow();
  196.     END;
  197.   END;
  198. END OutputStat;
  199.  
  200. PROCEDURE ToClip (ptr: WdwPtr);
  201.   VAR scrapPath : PutzTypes.MaxStr;
  202.       tf    : mtTextfiles.TEXTFILE;
  203.       fName : PutzTypes.FileStr;
  204.       fnShort : PutzTypes.FileStr;
  205.       state   : INTEGER;
  206.       msg     : PutzTypes.MaxStr;
  207.       entry   : ptrDispEntry;
  208.       
  209. BEGIN
  210.   IF Clip.GetScrap (scrapPath)
  211.   THEN
  212.     Clip.ScrapClear(scrapPath, '');
  213.     (* Datei anlegen *)
  214.     fnShort := "SCRAP.TXT";
  215.     Strings.Concat (scrapPath, fnShort, fName, v.bool);
  216.     IF ~mtTextfiles.OpenTextfile (fName, mtTextfiles.WRITE, 32000, tf)
  217.     THEN
  218.       v.int := mtAlerts.Alert (1, noClipAlt);
  219.       RETURN 
  220.     END;
  221.     outputText (ptr^.list, tf, FALSE);
  222.     fnShort := "SCRAP.CSV";
  223.     Strings.Concat (scrapPath, fnShort, fName, v.bool);
  224.     IF ~mtTextfiles.OpenTextfile (fName, mtTextfiles.WRITE, 32000, tf)
  225.     THEN
  226.       v.int := mtAlerts.Alert (1, noClipAlt);
  227.       RETURN 
  228.     END;
  229.     outputText (ptr^.list, tf, TRUE);
  230.     mtAppl.MouseArrow();
  231.   END;
  232. END ToClip;
  233.  
  234. PROCEDURE FindWindow (wdw: INTEGER): WdwPtr;
  235. BEGIN
  236.   IF windows # NIL
  237.   THEN
  238.     IF windows^.wdw = wdw
  239.     THEN
  240.       RETURN windows;
  241.     END;
  242.   END;
  243.   RETURN NIL;
  244. END FindWindow;
  245.  
  246. PROCEDURE FindLine (ptr: WdwPtr; line: INTEGER): ptrDispEntry;
  247.   VAR l  : List;
  248.       i  : INTEGER;
  249.       entry: ptrDispEntry;
  250. BEGIN
  251.   IF ptr # NIL
  252.   THEN
  253.     l := ptr^.list;
  254.     ResetList (l);
  255.     entry := NextEntry (l);
  256.     i := 0;
  257.     WHILE (entry # NIL) & (i < line) DO
  258.       INC (i);
  259.       entry := NextEntry (l);
  260.     END;
  261.     RETURN entry;
  262.   END;
  263.   RETURN NIL;
  264. END FindLine;
  265.  
  266. PROCEDURE LineIsSelectable(ptr: WdwPtr; line: INTEGER): BOOLEAN;
  267.   VAR entry : ptrDispEntry;
  268. BEGIN
  269.   entry := FindLine (ptr, line);
  270.   RETURN (entry # NIL) & (entry^.type = dataEntry) & (entry^.data^.info # NIL);
  271. END LineIsSelectable;
  272.  
  273. PROCEDURE LineIsSelected (ptr: WdwPtr; line: INTEGER): BOOLEAN;
  274.   VAR entry : ptrDispEntry;
  275. BEGIN
  276.   entry := FindLine (ptr, line);
  277.   RETURN (entry # NIL) & (entry^.data # NIL) & (entry^.data^.selected);
  278. END LineIsSelected;
  279.  
  280. PROCEDURE SelectLine (ptr: WdwPtr; line: INTEGER);
  281.   VAR entry : ptrDispEntry;
  282. BEGIN
  283.   entry := FindLine (ptr, line);
  284.   IF (entry # NIL) & (entry^.data # NIL)
  285.   THEN
  286.     entry^.data^.selected := NOT entry^.data^.selected;
  287.   END;
  288. END SelectLine;
  289.  
  290. PROCEDURE AdjustTreePos (r: Rectangle; VAR rt : Rectangle);
  291. BEGIN
  292.   WITH butBox^[0] DO
  293.     obX := r.x;
  294.     obY := r.y;
  295.     obWidth := r.w;
  296.     rt.x := obX; rt.y := obY;
  297.     rt.w := obWidth; rt.h := obHeight+1;
  298.   END;
  299. END AdjustTreePos;
  300.  
  301. PROCEDURE snapWdw (wdw, vdi : INTEGER; special : ADDRESS; VAR work : Rectangle);
  302.   CONST minWindWidth = 128;
  303.         minWindHeight = 48;
  304.  VAR wl : WdwPtr;
  305.      sLine: INTEGER;
  306.      wdwSize: Rectangle;
  307. BEGIN
  308.   wl := WdwPtr (special);
  309.   WITH wl^ DO
  310.     AdjustTreePos (work, butWork);
  311.     IF ~inOpen
  312.     THEN
  313.       WITH work DO
  314.         DEC (h, butWork.h);
  315.         INC (h);            (* Um Rundungsfehler zu vermeiden *)
  316.         h := ((h+lineDist) DIV (charHeight+lineDist)) * (charHeight+lineDist);
  317.         WHILE w < minWindWidth DO INC(w, charWidth) END;
  318.         WHILE h < minWindHeight DO INC(h, charHeight+lineDist) END;
  319.         windLines := (BinOps.LowerInt(y+h-1, INTEGER(mtAppl.MaxHeight-1)) - y+1) DIV (charHeight+lineDist); 
  320.         currSize := work;
  321.         INC (work.h, butWork.h);
  322.         WdwManager.SetScrollParms (wdw, w-charWidth, windLines-1, charWidth, 1);
  323.       END;
  324.       WindowParms (wdw, wdwSize, sLine);
  325.       v.bool := ConfVars.SetConfigInt (cWdwTop, sLine);
  326.       v.bool := ConfVars.SetConfigRect (cWdwRect, wdwSize);
  327.     END;
  328.     (*
  329.     IF startLine + (currSize.h) DIV charHeight > INTEGER(NoOfEntries (list))
  330.     THEN
  331.       WdwManager.SetWdwDocument (wdw, LongRect {leftOffset,
  332.                                  LONG(INTEGER(NoOfEntries(list)) - (currSize.h DIV charHeight)), 
  333.                                  maxWidth*charWidth, VAL(LONGINT, NoOfEntries (list)-1)});
  334.     END;
  335.     *)
  336.   END;
  337. END snapWdw;
  338.  
  339. PROCEDURE getScroll (wdw, vdiH : INTEGER; special : ADDRESS; VAR work : Rectangle);
  340.   VAR ptr       : WdwPtr;
  341.       full      : Rectangle;
  342. BEGIN 
  343.   ptr := WdwPtr (special);
  344.   AdjustTreePos (work, ptr^.butWork);
  345.   DEC (work.h, butBox^[0].obHeight+1);
  346.   INC (work.y, butBox^[0].obHeight+1);
  347.   WITH work DO
  348.     ptr^.windLines := (BinOps.LowerInt(y+h-1, INTEGER(mtAppl.MaxHeight-1)) - y+1) DIV (ptr^.charHeight+lineDist); 
  349.     WdwManager.SetScrollParms (wdw, w-ptr^.charWidth, ptr^.windLines-1, ptr^.charWidth, 1);
  350.     ptr^.currSize := work;
  351.   END;
  352. END getScroll;
  353.  
  354. PROCEDURE topWdw (wdw, vdi : INTEGER; special : ADDRESS) : BOOLEAN;
  355. BEGIN
  356.   RETURN TRUE
  357. END topWdw;
  358.  
  359. PROCEDURE closeWdw (wdw, vdi : INTEGER; special : ADDRESS; force : BOOLEAN) : BOOLEAN;
  360.  VAR wl : WdwPtr;
  361.      wdwSize: Rectangle;
  362.      sLine  : INTEGER;
  363. BEGIN
  364.  wl := WdwPtr (special);
  365.  WindowParms (wdw, wdwSize, sLine);
  366.  v.bool := ConfVars.SetConfigInt (cWdwTop, sLine);
  367.  v.bool := ConfVars.SetConfigRect (cWdwRect, wdwSize);
  368.  v.bool := ConfVars.SetConfigBool (cWdwOpen, FALSE);
  369.  FontSelect.UnloadFonts (vdi);
  370.  RETURN TRUE;
  371. END closeWdw;
  372.  
  373. PROCEDURE hasSelectedEntries (ptr : WdwPtr; VAR first : INTEGER): BOOLEAN;
  374.   VAR i : INTEGER;
  375.       entry : ptrDispEntry;
  376. BEGIN
  377.   WITH ptr^ DO
  378.     ResetList (list);
  379.     entry := NextEntry (list);
  380.     i := 0;
  381.     WHILE entry # NIL DO 
  382.       IF (entry^.data # NIL) & (entry^.data^.selected) THEN RETURN TRUE END;
  383.       INC (i);
  384.       entry := NextEntry (list);
  385.     END;
  386.   END;
  387.   RETURN FALSE;
  388. END hasSelectedEntries;
  389.  
  390. PROCEDURE countSelectedEntries (ptr : WdwPtr) : CARDINAL;
  391.   VAR i : INTEGER;
  392.       (*$Reg *) counter : CARDINAL;
  393.       entry : ptrDispEntry;
  394. BEGIN
  395.   WITH ptr^ DO
  396.     ResetList (list);
  397.     entry := NextEntry (list);
  398.     counter := 0;
  399.     WHILE entry # NIL DO 
  400.       IF (entry^.data # NIL) & (entry^.data^.selected) THEN INC (counter) END;
  401.       entry := NextEntry (list);
  402.     END;
  403.   END;
  404.   RETURN counter;
  405. END countSelectedEntries;
  406.  
  407. PROCEDURE redrawEntry (ptr: WdwPtr; line: INTEGER);
  408.   VAR rect : Rectangle;
  409. BEGIN
  410.   WITH ptr^ DO
  411.     IF (wdw < 0) OR isHidden THEN RETURN END;
  412.     (*
  413.     IF (line < startLine) OR (line > startLine + windLines + 1) THEN RETURN END;
  414.     *)
  415.     rect := currSize;
  416.     INC (rect.x, pixOff);
  417.     rect.y := rect.y + (line - startLine) * (charHeight+lineDist);
  418.     rect.h := charHeight + lineDist;
  419.     WdwManager.RedrawWdw (wdw, rect);
  420.   END;
  421. END redrawEntry;
  422.  
  423. PROCEDURE toggleEntry (ptr : WdwPtr; entry: INTEGER);
  424.   VAR rect : Rectangle;
  425. BEGIN
  426.   WITH ptr^ DO
  427.     IF LineIsSelectable (ptr, entry)
  428.     THEN
  429.       SelectLine (ptr, entry);
  430.       redrawEntry (ptr, entry);
  431.     END;
  432.   END;
  433. END toggleEntry;
  434.  
  435. PROCEDURE redrawButton (wdw: INTEGER; butBox: mtUtils.tObjcTree; ob: INTEGER);
  436.   VAR r : Rectangle;
  437. BEGIN
  438.   mtUtils.ObjcPos (butBox, ob, r.x, r.y);
  439.   DEC (r.x); DEC (r.y);
  440.   r.w := butBox^[ob].obWidth+1;
  441.   r.h := butBox^[ob].obHeight+1;
  442.   WdwManager.RedrawWdw (wdw, r);
  443. END redrawButton;
  444.  
  445. CONST   oneGroupSelTxt = "Eine Gruppe selektiert";
  446.         noGroupSelTxt  = "Keine Gruppe selektiert";
  447.         manyGroupSelTxt = " Gruppen selektiert";
  448.  
  449. PROCEDURE careForButtons(ptr : WdwPtr; redraw : BOOLEAN);
  450. (* Enablet/disablet die Buttonleiste *)
  451.   VAR selectCount : INTEGER;
  452.       rdwCount,
  453.       i         : INTEGER;
  454.       selSet,
  455.       disSet    : BITSET;
  456.       str       : PutzTypes.MaxStr;
  457. BEGIN
  458.   WITH ptr^ DO
  459.     selSet := {};
  460.     disSet := {};
  461.     FOR i := Delmsgs TO Saveconf DO
  462.       IF mtUtils.InState (butBox, i, MagicAES.SELECTED) THEN INCL (selSet, i); END;
  463.       IF mtUtils.InState (butBox, i, MagicAES.DISABLED) THEN INCL (disSet, i); END;
  464.     END;
  465.     (* selectCount := countSelectedEntries(ptr); *)
  466.     selectCount := PutzDo.CountSelectedEntries(putzList);
  467.     IF selectCount = 0
  468.     THEN
  469.       mtUtils.SetObjcString (butBox, Ctrltext, noGroupSelTxt);
  470.     ELSIF selectCount = 1
  471.     THEN
  472.       mtUtils.SetObjcString (butBox, Ctrltext, oneGroupSelTxt);
  473.     ELSE
  474.       MagicStrings.Assign (StrConv.IntToStr (selectCount, 0), str);
  475.       MagicStrings.Append (manyGroupSelTxt, str);
  476.       mtUtils.SetObjcString (butBox, Ctrltext, str);
  477.     END;
  478.     
  479.     mtUtils.SetState (butBox, Delmsgs, MagicAES.DISABLED, 
  480.                       (selectCount = 0));
  481.     mtUtils.SetState (butBox, Delgroup, MagicAES.DISABLED, 
  482.                       (selectCount # 1));
  483.     mtUtils.SetState (butBox, Confdel, MagicAES.DISABLED, 
  484.                       (selectCount = 0));
  485.     (* Alle neuzeichnen *)
  486.     IF redraw & (wdw >= 0) THEN 
  487.       rdwCount := 0;
  488.       FOR i := Delmsgs TO Saveconf DO
  489.         IF (mtUtils.InState (butBox, i, MagicAES.SELECTED) # (i IN selSet)) OR 
  490.            (mtUtils.InState (butBox, i, MagicAES.DISABLED) # (i IN disSet))
  491.         THEN
  492.           INC (rdwCount); 
  493.         END;
  494.       END;
  495.       IF rdwCount < 5
  496.       THEN
  497.         FOR i := Delmsgs TO Saveconf DO
  498.           IF (mtUtils.InState (butBox, i, MagicAES.SELECTED) # (i IN selSet)) OR 
  499.              (mtUtils.InState (butBox, i, MagicAES.DISABLED) # (i IN disSet))
  500.           THEN
  501.             redrawButton (wdw, butBox, i); 
  502.           END;
  503.         END;
  504.         redrawButton (wdw, butBox, Ctrltext);
  505.       ELSE
  506.         redrawButton (wdw, butBox, 0);
  507.       END;
  508.     END;
  509.   END;
  510. END careForButtons;
  511.  
  512. PROCEDURE handleButtons (ptr : WdwPtr; ob : INTEGER) : BOOLEAN;
  513.   VAR i      : INTEGER;
  514.       selectCount : INTEGER;
  515.       x, y   : INTEGER;
  516.       select : INTEGER;
  517.       grEntry: ptrGrEntry;
  518.       putzOpts: PutzTypes.putzOptsRec;
  519.       iStartLine,
  520.       iFont,
  521.       iFontSize: INTEGER;
  522.       wdwSize  : Rectangle;
  523.       sLine    : INTEGER;
  524. BEGIN
  525.   WITH ptr^ DO
  526.     IF ~mtUtils.InState (butBox, ob, MagicAES.DISABLED)
  527.       & mtUtils.InFlag (butBox, ob, MagicAES.SELECTABLE)
  528.     THEN
  529.       (* Button selektieren *)
  530.       mtUtils.InclState (butBox, ob, MagicAES.SELECTED);
  531.       redrawButton (wdw, butBox, ob);
  532.       mtUtils.Bounce();
  533.       inDelete := TRUE;
  534.       (* Selektierte Nachrichten z„hlen *)
  535.       selectCount := PutzDo.CountSelectedEntries(putzList);
  536.       CASE ob OF 
  537.         Saveas:     OutputStat (ptr); |
  538.         Copyclip:   ToClip (ptr); |
  539.         Selall:     PutzDo.SelectAll (TRUE); 
  540.                     WdwManager.RedrawWdw (wdw, currSize); |
  541.         Selnone:    PutzDo.SelectAll (FALSE);
  542.                     WdwManager.RedrawWdw (wdw, currSize); |
  543.         Delmsgs:    IF 1 = mtAlerts.Alert (1, doDelAlt)
  544.                     THEN
  545.                       inDelete := TRUE;
  546.                       MagicAES.WindUpdate (MagicAES.ENDUPDATE);
  547.                       PutzDo.InitDelete (wdw); 
  548.                       MagicAES.WindUpdate (MagicAES.BEGUPDATE);
  549.                       inDelete := FALSE;
  550.                       WdwManager.FullRedrawWdw (wdw);
  551.                     END; |
  552.         Delgroup:   grEntry := PutzDo.FirstSelectedGroup(putzList);
  553.                     IF (grEntry # NIL) & (grEntry^.info^.catNumber # dataSys.private)
  554.                     THEN
  555.                       inDelete := TRUE;
  556.                       IF PutzGroup.deleteGroup (grEntry, FALSE)
  557.                       THEN
  558.                         groupDeleted := TRUE;
  559.                         PutzGr.ClearDisplayList();
  560.                         PutzGr.BuildDisplayList(PutzTypes.displayList);
  561.                         PutzDo.CalcTotals();
  562.                         SetNewList (wdw, PutzTypes.displayList);
  563.                       END;
  564.                       inDelete := FALSE;
  565.                     END; |
  566.         Config :    IF selectCount = 0
  567.                     THEN
  568.                       v.bool := PutzRsc.doOptBox (FALSE, defaultOpts);
  569.                     ELSE
  570.                       IF selectCount = 1
  571.                       THEN
  572.                         grEntry := PutzDo.FirstSelectedGroup (putzList);
  573.                         putzOpts := PutzDo.InitGroupFlags (grEntry^.info^.catNumber, TRUE, v.bool);
  574.                       ELSE
  575.                         putzOpts := defaultOpts;
  576.                       END;
  577.                       (* Dialog ausfhren *)
  578.                       IF PutzRsc.doOptBox (TRUE, putzOpts)
  579.                       THEN
  580.                         grEntry := PutzDo.FirstSelectedGroup (putzList);
  581.                         WHILE grEntry # NIL DO
  582.                           (* Und jetzt noch die Konfigvariablen setzen *)
  583.                           PutzDo.SetGroupFlags (grEntry^.info^.catNumber, putzOpts);
  584.                           grEntry := PutzDo.NextSelectedGroup (putzList, grEntry^.info^.catNumber);
  585.                         END;
  586.                       END;
  587.                     END; |
  588.         Confdel:    IF selectCount > 0
  589.                     THEN
  590.                       grEntry := PutzDo.FirstSelectedGroup (putzList);
  591.                       WHILE grEntry # NIL DO
  592.                         (* Konfigvariablen l”schen *)
  593.                         PutzDo.DeleteGroupFlags (grEntry^.info^.catNumber);
  594.                         grEntry := PutzDo.NextSelectedGroup (putzList, grEntry^.info^.catNumber);
  595.                       END;
  596.                     END; |
  597.         Confopt:    Strings.Assign (PutzTypes.tmpPath, defaultOpts.tmpDir, v.bool);
  598.                     IF PutzRsc.doPathBox(defaultOpts.useTmp, defaultOpts.tmpDir)
  599.                     THEN
  600.                       IF defaultOpts.useTmp
  601.                       THEN
  602.                         Strings.Assign (defaultOpts.tmpDir, PutzTypes.tmpPath, v.bool);
  603.                       ELSE
  604.                         Strings.Assign (MTPaths.DataPath, PutzTypes.tmpPath, v.bool);
  605.                       END;
  606.                     END; |
  607.         Fontsel:    GetWindowFont (wdw, iFont, iFontSize);
  608.                     IF FontSelect.DoSelectFont (vdi, FALSE, iFont, iFontSize)
  609.                     THEN
  610.                       SetWindowFont (wdw, iFont, iFontSize); 
  611.                     END; |
  612.         Loadinf:    isLocked := TRUE;
  613.                     v.bool := PutzGr.ReadNewInf();
  614.                     (* Fenster neu initialisieren 
  615.                      * Font und Gr”že 
  616.                      *) 
  617.                     (* Variablen neu lesen *)
  618.                     ConfVars.GetConfDefInt (cWdwFont, iFont, 1);
  619.                     ConfVars.GetConfDefInt (cWdwFontSize, iFontSize, 10);
  620.                     ConfVars.GetConfDefInt (cWdwTop, iStartLine, 0);
  621.                     ConfVars.GetConfDefRect (cWdwRect, wdwSize, WdwManager.deskSize);
  622.                     ConfVars.GetConfDefInt (cWdwLineDist, lineDist, 2);
  623.                     ConfVars.GetConfDefInt (cWdwLeftOffs, pixOff, 8);
  624.                     (* Jetzt bernehmen *)
  625.                     WdwManager.SetWdwSize (wdw, wdwSize);
  626.                     (* Font setzen *)
  627.                     SetWindowFont (wdw, iFont, iFontSize); 
  628.                     (* Und jetzt die Liste wechseln *)
  629.                     startLine := iStartLine;
  630.                     isLocked := FALSE;
  631.                     SetNewList (wdw, PutzTypes.displayList);
  632.                     |
  633.         Saveconf:   (* Ein paar Parameter sichern *)
  634.                     WindowParms (wdw, wdwSize, sLine);
  635.                     v.bool := ConfVars.SetConfigInt (cWdwTop, sLine);
  636.                     v.bool := ConfVars.SetConfigRect (cWdwRect, wdwSize);
  637.                     v.bool := ConfVars.SetConfigBool (cWdwOpen, TRUE);
  638.                     PutzRsc.SaveParameter (MTPaths.DataPath); |
  639.  
  640.       ELSE
  641.       END;
  642.       careForButtons (ptr, TRUE);
  643.       (* Button deselektieren *)
  644.       mtUtils.ExclState (butBox, ob, MagicAES.SELECTED);
  645.       redrawButton (ptr^.wdw, butBox, ob);
  646.       inDelete := FALSE;
  647.       RETURN TRUE
  648.     ELSE
  649.       RETURN FALSE;
  650.     END;
  651.   END;
  652. END handleButtons;
  653.  
  654. PROCEDURE clickInWindow(win, vdiH : INTEGER; special : ADDRESS; 
  655.                         x,y : INTEGER; kstate, buts : BITSET; clicks : INTEGER): BOOLEAN;
  656. VAR ptr: WdwPtr;
  657.     transY : INTEGER;
  658.     ob : INTEGER;
  659.     entrySelected : BOOLEAN;
  660.     line   : INTEGER;
  661.     but    : BITSET;
  662.     i      : INTEGER;
  663.     selectCount : INTEGER;
  664.  
  665.     PROCEDURE selectArea;
  666.       VAR firstLine,
  667.           lastLine : INTEGER;
  668.           i        : INTEGER;
  669.           r, 
  670.           rect     : Rectangle;
  671.           first    : BOOLEAN;
  672.     BEGIN
  673.       WITH ptr^ DO
  674.         rect := Rectangle{x, y, 0, 0};
  675.         mtAppl.MouseFinger ();
  676.         MagicAES.GrafRubberbox (x, y, -32767, -32767, rect.w, rect.h);
  677.         mtAppl.MouseArrow();
  678.         
  679.         WITH rect DO
  680.           IF w < 0
  681.           THEN
  682.             INC(x, w);
  683.             w := -w
  684.           END;
  685.           IF h < 0
  686.           THEN
  687.             INC (y, h);
  688.             h := -h
  689.           END;
  690.         END;
  691.         (* clippen *)
  692.         rect := RectFuncs.ClipRect (rect, currSize);
  693.         rect.h := BinOps.LowerInt (rect.h, currSize.y + currSize.h - 1 - rect.y);
  694.         
  695.         (* Jetzt testen, ob selektierbarer Bereich geschnitten wurde *)
  696.         IF (((rect.x - currSize.x) < pixOff) & ((rect.x + rect.w - currSize.x) < pixOff)) OR
  697.            (((rect.x - currSize.x) > maxWidth*charWidth) & ((rect.x + rect.w - currSize.x) > maxWidth*charWidth))
  698.         THEN
  699.           RETURN
  700.         END;
  701.  
  702.         firstLine := (rect.y - currSize.y) DIV (charHeight + lineDist);
  703.         lastLine  := (rect.y + rect.h - currSize.y) DIV (charHeight + lineDist);
  704.         IF (rect.x - currSize.x > pixOff) OR (rect.x + rect.w - currSize.x > pixOff)
  705.         THEN
  706.           r := currSize;
  707.           INC (r.x, pixOff);
  708.           r.h := charHeight + lineDist;
  709.           first := TRUE;
  710.           FOR i := startLine+firstLine TO startLine+lastLine DO
  711.             IF (i>= 0) & LineIsSelectable (ptr, i)
  712.             THEN
  713.               SelectLine (ptr, i);
  714.  
  715.               IF (i >= startLine) & (i <= startLine + windLines)
  716.               THEN 
  717.                 (* redraw *)
  718.                 IF first THEN 
  719.                   r.y := currSize.y + INTEGER(i - startLine) * (charHeight+lineDist);
  720.                   first := FALSE
  721.                 ELSE
  722.                   r.h := currSize.y + INTEGER(i - startLine + 1) * (charHeight+lineDist) - r.y;
  723.                 END;
  724.               END;
  725.             END;
  726.           END;
  727.           IF ~first THEN WdwManager.RedrawWdw (wdw, r) END;
  728.         END;
  729.       END;
  730.     END selectArea;
  731.  
  732. BEGIN
  733.   ptr := WdwPtr (special);
  734.   WITH ptr^ DO
  735.     IF inDelete THEN RETURN FALSE END;
  736.     IF isLocked THEN RETURN FALSE END;
  737.     IF ~(0 IN buts) THEN RETURN FALSE END;
  738.     IF RectFuncs.IsInRect (x, y, butWork)
  739.     THEN
  740.       ob := MagicAES.ObjcFind (butBox,  0, 8, x, y);
  741.       IF (ob >= Delmsgs) & (ob <= Saveconf)
  742.       THEN
  743.         RETURN handleButtons (ptr, ob);
  744.       END;
  745.     ELSIF RectFuncs.IsInRect (x, y, currSize)
  746.     THEN
  747.       IF ~((MagicAES.KRSHIFT IN kstate) OR (MagicAES.KLSHIFT IN kstate))
  748.       THEN
  749.         (* deselectEntries (ptr); *)
  750.       END;
  751.       (* Zeile herausfinden *)
  752.       line := (y - currSize.y) DIV (charHeight + lineDist);
  753.       transY := (y - currSize.y - (lineDist DIV 2));
  754.       entrySelected := (transY >= line*(charHeight + lineDist)) & 
  755.                        (transY < ((line+1) * charHeight + line*lineDist)) &
  756.                        ((x - currSize.x) >= pixOff) &
  757.                        ((x - currSize.x) <= maxWidth*charWidth);
  758.       IF entrySelected
  759.       THEN
  760.         toggleEntry (ptr, line+startLine);
  761.         REPEAT 
  762.           MagicAES.GrafMkstate (x, y, but, kstate);
  763.         UNTIL ~(0 IN but);
  764.       ELSE
  765.         MagicAES.GrafMkstate (x, y, but, kstate);
  766.         IF 0 IN but
  767.         THEN
  768.           (* Graf-Rubberbox aufrufen *)
  769.           selectArea();
  770.         END;
  771.       END;
  772.       careForButtons (ptr, TRUE);
  773.       RETURN TRUE;
  774.     END;
  775.   END;
  776.   RETURN FALSE;
  777. END clickInWindow;
  778.  
  779. PROCEDURE GetString (ob: INTEGER; VAR str: ARRAY OF CHAR);
  780. BEGIN
  781.   CASE ob OF
  782.     Delmsgs:    MagicStrings.Assign ("Nachrichten in Gruppen l”schen (^D)", str); |
  783.     Delgroup:   MagicStrings.Assign ("Gruppe l”schen (^G)", str); |
  784.     Selall:     MagicStrings.Assign ("Alle selektieren (^A)", str); |
  785.     Selnone:    MagicStrings.Assign ("Selektion aufheben (^H)", str); |
  786.     Loadinf:    MagicStrings.Assign ("CAT.INF laden ... (^L)", str); |
  787.     Saveas:     MagicStrings.Assign ("Fenster speichern als ... (^S)", str); |
  788.     Copyclip:   MagicStrings.Assign ("Fenster kopieren (^C)", str); |
  789.     Fontsel:    MagicStrings.Assign ("Zeichensatz ausw„hlen (Z)", str); |
  790.     Config:     MagicStrings.Assign ("Flags einstellen ...  (F)", str); |
  791.     Confdel:    MagicStrings.Assign ("Flags l”schen (K)", str); |
  792.     Confopt:    MagicStrings.Assign ("Einstellungen ... (E)", str); |
  793.     Saveconf:   MagicStrings.Assign ("Einstellungen sichern (S)", str); |
  794.   ELSE
  795.     MagicStrings.Assign ("", str);
  796.   END;
  797. END GetString;
  798.  
  799. PROCEDURE handleRect (wdw, vdiH: INTEGER; special: ADDRESS; which: INTEGER;
  800.                       moX, moY : INTEGER): BOOLEAN;
  801.   VAR ptr: WdwPtr;
  802.       ob : INTEGER;
  803.       str: PutzTypes.MaxStr;
  804. BEGIN
  805.   ptr := WdwPtr (special);
  806.   WITH ptr^ DO
  807.     IF RectFuncs.IsInRect (moX, moY, butWork)
  808.     THEN
  809.       ob := MagicAES.ObjcFind (butBox,  0, 8, moX, moY);
  810.     ELSE
  811.       ob := -1;
  812.     END;
  813.     IF lastOb # ob
  814.     THEN
  815.       lastOb := ob;
  816.       GetString (ob, str);
  817.       mtUtils.SetObjcString (butBox, Flyhelp, str);
  818.       redrawButton (wdw, butBox, Flyhelp);
  819.       RETURN TRUE;
  820.     END;
  821.   END;
  822.   RETURN FALSE;
  823. END handleRect;
  824.  
  825. PROCEDURE handlePutzKey (wdw, vdiH : INTEGER; special : ADDRESS; taste: INTEGER; char, scan : CHAR; kstate : BITSET) : BOOLEAN;
  826.   VAR ptr : WdwPtr;
  827.       gemCh : CARDINAL;
  828.       key   : MOSGlobals.Key;
  829.       ctrl  : BOOLEAN;
  830.       shift : BOOLEAN;
  831.       done  : BOOLEAN;
  832. BEGIN
  833.   ptr := WdwPtr (special);
  834.   WITH ptr^ DO
  835.     gemCh := ORD(scan) * 256 + ORD(char);
  836.     Keyboard.GemCharToKey (gemCh,  SHORT (INTEGER(kstate)), key);
  837.     ctrl := CatGlobal.WithCtrl (kstate);
  838.     shift := CatGlobal.WithShift (kstate);
  839.     done := TRUE;
  840.     IF Keyboard.IsSpecial (key)
  841.     THEN
  842.       CASE Keyboard.SpecialKey (key) OF
  843.         home          : startLine := 0;
  844.                         WdwManager.SetWdwDocument (wdw, LongRect{LONG(leftOffset), 0, LONG(maxWidth*charWidth), 
  845.                               VAL(LONGINT, NoOfEntries (list))}); |
  846.         clr           : startLine := INTEGER(NoOfEntries (list)) - windLines + 1;
  847.                         WdwManager.SetWdwDocument (wdw, LongRect{LONG(leftOffset), VAL(LONGINT, NoOfEntries (list)) - LONG(windLines) + 1, LONG(maxWidth*charWidth), 
  848.                               VAL(LONGINT, NoOfEntries (list))}); |
  849.         left          : WdwManager.ScrollLeft (wdw, 1);  |
  850.         soln          : WdwManager.PageLeft (wdw);    |
  851.         right         : WdwManager.ScrollRight (wdw, 1); | 
  852.         eoln          : WdwManager.PageRight (wdw);   |
  853.         up            : WdwManager.ScrollUp (wdw, 1); |
  854.         down          : WdwManager.ScrollDown (wdw, 1); |
  855.         pgUp          : WdwManager.PageUp (wdw);      |
  856.         pgDown        : WdwManager.PageDown (wdw);    |
  857.         help          : PutzHelp.DoHelp (PutzHelp.window); |
  858.         
  859.         (* CatPutz-Keys *)
  860.         ctrlD         : RETURN handleButtons (ptr, Delmsgs); |
  861.         ctrlG         : RETURN handleButtons (ptr, Delgroup); |
  862.         ctrlA         : RETURN handleButtons (ptr, Selall); |
  863.         ctrlH         : RETURN handleButtons (ptr, Selnone); |
  864.         ctrlL         : RETURN handleButtons (ptr, Loadinf); |
  865.         ctrlS         : RETURN handleButtons (ptr, Saveas); |
  866.         ctrlC         : RETURN handleButtons (ptr, Copyclip); |
  867.         altZ          : RETURN handleButtons (ptr, Fontsel); |
  868.         altF          : RETURN handleButtons (ptr, Config); |
  869.         altK          : RETURN handleButtons (ptr, Confdel); |
  870.         altE          : RETURN handleButtons (ptr, Confopt); |
  871.         altS          : RETURN handleButtons (ptr, Saveconf); |
  872.       ELSE
  873.         done := FALSE
  874.       END;
  875.     ELSE
  876.       done := FALSE;
  877.     END;
  878.     RETURN done;
  879.   END;
  880.   RETURN FALSE
  881. END handlePutzKey;
  882.  
  883. PROCEDURE GetTextWidth (ptr: WdwPtr; REF str: ARRAY OF CHAR; VAR width: INTEGER);
  884.  VAR  extent     : ARRAY [0..3] OF Point;
  885. BEGIN
  886.   WITH ptr^ DO
  887.     IF str[0] = 0C THEN 
  888.       width := 0;
  889.       RETURN
  890.     END;
  891.     IF fontScalable
  892.     THEN
  893.       MagicFSM.InqFExtent (vdi, str, extent);
  894.     ELSE 
  895.       MagicVDI.InqTextextent (vdi, str, extent);
  896.     END;
  897.     width := extent[1].x - extent[0].x;
  898.   END;
  899. END GetTextWidth;
  900.  
  901. PROCEDURE drawWdw (wdw, vdi : INTEGER; special : ADDRESS; frame : Rectangle); (* x, y, w, h : sINTEGER); *)
  902. VAR entry : ptrDispEntry;
  903.     str : ARRAY [0..255] OF CHAR;
  904.     part,
  905.     xCoor,
  906.     width,
  907.     xOffset,
  908.     yOutput,
  909.     i   : INTEGER;
  910.     just: TextJustification;
  911.     clip: Rectangle;
  912.     wl  : WdwPtr;
  913.     fill   : Rectangle;
  914.     tWidth,
  915.     tempX   : INTEGER;
  916. BEGIN
  917.   wl := WdwPtr (special);
  918.   WITH wl^ DO
  919.     clip := frame;
  920.     IF RectFuncs.rcIntersect (butWork, clip)
  921.     THEN
  922.       careForButtons (wl, FALSE);
  923.       mtDials.DialDraw (butBox, 0, 8, clip, TRUE);
  924.       mtAppl.MouseOff();
  925.     END;
  926.     
  927.     clip := frame;
  928.     IF RectFuncs.rcIntersect (currSize, clip)
  929.     THEN
  930.       
  931.       clip := RectFuncs.ClipRect (frame, currSize);
  932.       clip.w := clip.x + clip.w - 1; 
  933.       clip.h := clip.y + clip.h -1;
  934.       
  935.       MagicVDI.FillRectangle(vdi, clip);
  936.       
  937.       IF ~isLocked
  938.       THEN
  939.     
  940.         IF clip.x = currSize.x THEN
  941.           INC (clip.x, pixOff);
  942.         END;
  943.     
  944.         clip.x := BinOps.LowerInt (clip.x, clip.w);
  945.     
  946.         WdwManager.SetClip (vdi, clip, FALSE);
  947.     
  948.         ResetList (list);
  949.         entry := NextEntry (list);
  950.         i := 0;
  951.         WHILE (entry # NIL) & (i<startLine) DO
  952.           entry := NextEntry (list);
  953.           INC(i);
  954.         END;
  955.         i := 0;
  956.     
  957.         xCoor := currSize.x + pixOff - leftOffset;
  958.         yOutput := currSize.y + i * (charHeight + lineDist) + (lineDist DIV 2);
  959.         v.int := MagicVDI.SetFillcolor (vdi, MagicAES.BLACK);
  960.         WHILE (entry # NIL) & (yOutput <= clip.h) DO
  961.           xOffset := 0;
  962.     
  963.           IF entry^.type = separatorLine
  964.           THEN
  965.             (* Linie zeichnen *)
  966.             fill.x := xCoor;
  967.             fill.y := yOutput + (charHeight DIV 2) - (lineHeight DIV 2);
  968.             fill.w := xCoor + maxWidth*charWidth - 1;
  969.             fill.h := fill.y + lineHeight - 1;
  970.             (* Schreibmodus setzen *)
  971.             v.int := MagicVDI.SetWritemode (vdi, MagicVDI.REPLACE);
  972.             MagicVDI.FillRectangle(vdi, fill);
  973.             v.int := MagicVDI.SetWritemode (vdi, MagicVDI.TRANSPARENT);
  974.           ELSE
  975.             FOR part := 0 TO PutzList.GetPartCount() DO
  976.               width := PutzList.GetPartWidth (part);
  977.               PutzList.GetPart (entry, part, str, FALSE);
  978.               just := PutzList.GetPartJustification (entry, part);
  979.               (* Justification noch behandeln *)
  980.               IF just = justLeft
  981.               THEN
  982.                 (* MagicVDI.SetTextalignment (vdi, 0, 3, i, i); *)
  983.                 MagicVDI.Text (vdi, xCoor+xOffset, yOutput+charHeight-1, str);
  984.               ELSIF just = justCenter
  985.               THEN
  986.                 GetTextWidth (wl, str, tWidth);
  987.                 tempX := xCoor + xOffset + (((width * charWidth) - tWidth) DIV 2);
  988.                 (*  MagicVDI.SetTextalignment (vdi, 1, 3, i, i); *)
  989.                 MagicVDI.Text (vdi, tempX, yOutput+charHeight-1, str);
  990.               ELSE
  991.                 GetTextWidth (wl, str, tWidth);
  992.                 tempX := xCoor + xOffset + (width * charWidth) - tWidth - 1;
  993.                 (* MagicVDI.SetTextalignment (vdi, 2, 3, i, i); *)
  994.                 MagicVDI.Text (vdi, tempX, yOutput+charHeight-1, str);
  995.               END;
  996.               INC (xOffset, (width+2) * charWidth);
  997.             END;
  998.     
  999.             IF (entry^.data # NIL) & (entry^.data^.selected)
  1000.             THEN
  1001.               fill.x := xCoor;
  1002.               fill.y := yOutput;
  1003.               fill.w := xCoor + maxWidth*charWidth - 1;
  1004.               fill.h := yOutput + charHeight ;
  1005.               (* Schreibmodus setzen *)
  1006.               v.int := MagicVDI.SetWritemode (vdi, MagicVDI.XOR);
  1007.               MagicVDI.FillRectangle(vdi, fill);
  1008.               v.int := MagicVDI.SetWritemode (vdi, MagicVDI.TRANSPARENT);
  1009.             END;
  1010.     
  1011.           END;
  1012.  
  1013.           entry := NextEntry(list);
  1014.           INC (yOutput, charHeight+lineDist);
  1015.           INC(i);
  1016.         END;
  1017.         v.int := MagicVDI.SetFillcolor (vdi, MagicAES.WHITE);
  1018.       END;
  1019.     END;
  1020.   END;
  1021. END drawWdw;
  1022.  
  1023. PROCEDURE updateWdw (wdw, vdi : INTEGER; special : ADDRESS; begin: BOOLEAN);
  1024. BEGIN
  1025.   IF begin
  1026.   THEN
  1027.     MagicAES.WindUpdate (MagicAES.BEGUPDATE);
  1028.     mtAppl.MouseOff;
  1029.   ELSE
  1030.     mtAppl.MouseOn;
  1031.     MagicAES.WindUpdate (MagicAES.ENDUPDATE);
  1032.   END
  1033. END updateWdw;
  1034.  
  1035. PROCEDURE setWork (wdw, vdi : INTEGER; special : ADDRESS; doc : LongRect; slided : BOOLEAN);
  1036.   VAR wl : WdwPtr;
  1037. BEGIN
  1038.   wl := WdwPtr (special);
  1039.   wl^.startLine := SHORT(doc.y);
  1040.   wl^.leftOffset := SHORT(doc.x);
  1041. END setWork;
  1042.  
  1043. PROCEDURE hideWdw (wdw, vdiH : INTEGER; special : ADDRESS; hide : BOOLEAN);
  1044.   VAR ptr       : WdwPtr;
  1045. BEGIN 
  1046.   ptr := WdwPtr (special);
  1047.   ptr^.isHidden := hide;
  1048. END hideWdw;
  1049.  
  1050. PROCEDURE OpenWindow (l       : List;
  1051.                       VAR wdwHandle: INTEGER);
  1052.   VAR i   : INTEGER;
  1053.       wl  : WdwPtr;
  1054.       title: ARRAY [0..255] OF CHAR;
  1055. BEGIN
  1056.  butBox := PutzRsc.GetTreeAddr (Groupwdw);
  1057.  wdwHandle := -1;
  1058.  NEW (wl);
  1059.  IF wl = NIL
  1060.  THEN
  1061.    RETURN;
  1062.  END;
  1063.  WITH wl^ DO
  1064.    (* Defaults lesen *)   
  1065.    ConfVars.GetConfDefInt (cWdwFont, font, 1);
  1066.    ConfVars.GetConfDefInt (cWdwFontSize, fontSize, 10);
  1067.    ConfVars.GetConfDefInt (cWdwTop, startLine, 0);
  1068.    ConfVars.GetConfDefRect (cWdwRect, currSize, WdwManager.deskSize);
  1069.    ConfVars.GetConfDefInt (cWdwLineDist, lineDist, 2);
  1070.    ConfVars.GetConfDefInt (cWdwLeftOffs, pixOff, 8);
  1071.    
  1072.    wdw := -1;
  1073.    list := l;
  1074.    inOpen := TRUE;
  1075.    title := " CatPutz ";
  1076.    IF ~WdwManager.OpenWindow (clickInWindow, handlePutzKey, 
  1077.                               WdwManager.handleTimerProc(NIL), WdwManager.deskSize, currSize, 
  1078.                               {0..3}+{5..11}, TRUE, "", title, snapWdw, closeWdw, 
  1079.                               drawWdw, topWdw, WdwManager.untopProc (NIL), updateWdw, setWork, 
  1080.                               getScroll, hideWdw, pixOff, wl, FALSE, TRUE, TRUE, TRUE, wdw, vdi)
  1081.    THEN
  1082.      DISPOSE (wl);
  1083.      inOpen := FALSE;
  1084.      RETURN 
  1085.    END;
  1086.    v.bool := WdwManager.SetWindowRectProc (wdw, handleRect);
  1087.    v.bool := ConfVars.SetConfigBool (cWdwOpen, TRUE);
  1088.    wdwHandle := wdw;
  1089.    isHidden := FALSE;
  1090.    isLocked := FALSE;
  1091.    FontSelect.LoadFonts (vdi, i);
  1092.  
  1093.    FontSelect.SetFont (vdi, font, fontSize, TRUE, 
  1094.                        v.bool, fontScalable, charWidth, charHeight);
  1095.  
  1096.    (*
  1097.    FontSelect.FontSelect (vdi, font);
  1098.    fontSize := FontSelect.FontSize (vdi, fontSize, i,i,charWidth,charHeight);
  1099.    *)
  1100.    mtUtils.SetObjcString (butBox, Flyhelp, "");
  1101.    lastOb := -1;
  1102.    leftOffset := 0;
  1103.    
  1104.    PutzList.SetMaxNameLength (PutzGr.MaxNameLength());
  1105.    maxWidth := PutzList.GetMaxLineWidth() + (2 * PutzList.GetPartCount()) + 2;
  1106.    i := MagicVDI.SetFillstyle (vdi, MagicVDI.Full);
  1107.    i := MagicVDI.SetFillcolor (vdi, MagicAES.WHITE);
  1108.    (* Schreibmodus setzen *)
  1109.    i := MagicVDI.SetWritemode (vdi, MagicVDI.REPLACE);
  1110.    (* Textalignment setzen *)
  1111.    MagicVDI.SetTextalignment (vdi, 0, 3, i, i);
  1112.    
  1113.    WdwManager.SnapWdw (wdw);
  1114.    WdwManager.SetNewDocument (wdw, LongRect{LONG(leftOffset), LONG(startLine), LONG(maxWidth*charWidth), 
  1115.                               VAL(LONGINT, NoOfEntries (list))}, FALSE);
  1116.    WdwManager.SetDocumentParms (wdw, 1, charHeight+lineDist);
  1117.    WdwManager.SetScrollParms (wdw, currSize.w-charWidth, windLines-1, charWidth, 1);
  1118.    inOpen := FALSE;
  1119.  END;
  1120.  windows := wl;
  1121. END OpenWindow;
  1122.  
  1123. PROCEDURE WindowParms (wdw: INTEGER; VAR size : Rectangle; VAR start : INTEGER);
  1124. (* Gibt Gr”že des Windows wl in size zurck *)
  1125.   VAR wl: WdwPtr;
  1126. BEGIN
  1127.   wl := FindWindow (wdw);
  1128.   IF (wl # NIL)
  1129.   THEN
  1130.     WdwManager.GetWdwSize (wl^.wdw, size);
  1131.     IF (size.x < 0) OR (size.y < 0) OR (size.w <= 0) OR (size.h <= 0)
  1132.     THEN
  1133.       size := WdwManager.deskSize;
  1134.     END;
  1135.     start := wl^.startLine;
  1136.   END;
  1137. END WindowParms;
  1138.  
  1139. PROCEDURE GetWindowFont (wdw: INTEGER; VAR Font, FontSize : INTEGER);
  1140.   VAR wl: WdwPtr;
  1141. BEGIN
  1142.   wl := FindWindow (wdw);
  1143.   IF wl # NIL
  1144.   THEN
  1145.     WITH wl^ DO
  1146.       Font := font;
  1147.       FontSize := fontSize;
  1148.     END;
  1149.   END;
  1150. END GetWindowFont;
  1151.  
  1152. PROCEDURE SetWindowFont (wdw: INTEGER; Font, FontSize : INTEGER);
  1153.   VAR wl: WdwPtr;
  1154. BEGIN
  1155.   wl := FindWindow (wdw);
  1156.   IF wl # NIL
  1157.   THEN
  1158.     WITH wl^ DO
  1159.       font := Font;
  1160.       fontSize := FontSize;
  1161.       FontSelect.SetFont (vdi, font, fontSize, TRUE, 
  1162.                           v.bool, fontScalable, charWidth, charHeight);
  1163.  
  1164.       v.bool := ConfVars.SetConfigInt (cWdwFont, font);
  1165.       v.bool := ConfVars.SetConfigInt (cWdwFontSize, fontSize);
  1166.       (*
  1167.       FontSelect.FontSelect (vdi, font);
  1168.       fontSize := FontSelect.FontSize (vdi, fontSize, v.int, v.int, charWidth, charHeight);
  1169.       *)
  1170.       (* Textalignment setzen *)
  1171.       MagicVDI.SetTextalignment (vdi, 0, 3, v.int, v.int);
  1172.  
  1173.       (* Redraw ausl”sen *)
  1174.       WdwManager.SetDocumentParms (wdw, 1, charHeight+lineDist);
  1175.       WdwManager.SnapWdw (wdw);
  1176.       WdwManager.SetNewDocument (wdw, LongRect{LONG(leftOffset), LONG(startLine), LONG(maxWidth*charWidth), 
  1177.                                  VAL(LONGINT, NoOfEntries (list))}, FALSE);
  1178.       WdwManager.FullRedrawWdw (wdw);
  1179.     END;
  1180.   END;
  1181. END SetWindowFont;
  1182.  
  1183.  
  1184. PROCEDURE FindEntryByAddr (wdw: sINTEGER; info: ADDRESS; 
  1185.                            VAR line: INTEGER): BOOLEAN;
  1186.   VAR wl: WdwPtr;
  1187.       l : List;
  1188.       found : BOOLEAN;
  1189.       entry: ptrDispEntry;
  1190. BEGIN
  1191.   found := FALSE;
  1192.   wl := FindWindow (wdw);
  1193.   IF wl # NIL
  1194.   THEN
  1195.     l := wl^.list;
  1196.     ResetList (l);
  1197.     entry := NextEntry (l);
  1198.     line := 0;
  1199.     found := FALSE;
  1200.     WHILE (entry # NIL) & ~found DO
  1201.       found := (entry^.type = dataEntry) & (entry^.data = info);
  1202.       IF ~found
  1203.       THEN
  1204.         INC (line);
  1205.         entry := NextEntry (l);
  1206.       END;
  1207.     END;
  1208.   END;
  1209.   RETURN found;
  1210. END FindEntryByAddr;
  1211.  
  1212. PROCEDURE DeselectEntry (wdw: sINTEGER; entry: ADDRESS);
  1213.   VAR wl: WdwPtr;
  1214.       line : INTEGER;
  1215. BEGIN
  1216.   wl := FindWindow (wdw);
  1217.   IF wl # NIL
  1218.   THEN
  1219.     IF FindEntryByAddr (wdw, entry, line)
  1220.     THEN
  1221.       IF LineIsSelectable (wl, line)
  1222.       &  LineIsSelected (wl, line)
  1223.       THEN
  1224.         SelectLine (wl, line);
  1225.       END;
  1226.     END;
  1227.   END;
  1228. END DeselectEntry;
  1229.  
  1230. PROCEDURE RedrawEntry (wdw: INTEGER; entry: ADDRESS);
  1231.   VAR wl: WdwPtr;
  1232.       line : INTEGER;
  1233. BEGIN
  1234.   wl := FindWindow (wdw);
  1235.   IF wl # NIL
  1236.   THEN
  1237.     IF FindEntryByAddr (wdw, entry, line)
  1238.     THEN
  1239.       redrawEntry (wl, line);
  1240.     END;
  1241.   END;
  1242. END RedrawEntry;
  1243.  
  1244. PROCEDURE SetNewList (wdw: INTEGER; l : List);
  1245.   VAR wl: WdwPtr;
  1246. BEGIN
  1247.   wl := FindWindow (wdw);
  1248.   IF wl # NIL
  1249.   THEN
  1250.     wl^.list := l;
  1251.     PutzList.SetMaxNameLength (PutzGr.MaxNameLength());
  1252.     wl^.maxWidth := PutzList.GetMaxLineWidth() + (2 * PutzList.GetPartCount()) + 2;
  1253.     WdwManager.SetNewDocument (wl^.wdw, LongRect{wl^.leftOffset, LONG(wl^.startLine), wl^.maxWidth*wl^.charWidth, VAL(LONGINT, NoOfEntries (wl^.list))}, FALSE);
  1254.     WdwManager.FullRedrawWdw (wl^.wdw);
  1255.   END;
  1256. END SetNewList;
  1257.  
  1258. PROCEDURE IsPutzWindow (wdw: INTEGER): BOOLEAN;
  1259. BEGIN
  1260.   RETURN FindWindow (wdw) # NIL;
  1261. END IsPutzWindow;
  1262.  
  1263. BEGIN
  1264.   inDelete := FALSE;
  1265.   inOpen := FALSE;
  1266.   pixOff := 8;
  1267.   lineDist := 3;
  1268.   lineHeight := 2;
  1269. END PutzWindows.
  1270.